---
title: withIdleTimer
description: Higher order component for class-based React applications
---

Higher order component for class-based React applications. The `withIdleTimer` 
HOC takes [IIdleTimerProps](/docs/api/props) as configuration options and exposes
[IIdleTimer](/docs/api/methods) as props to the wrapped component.

## Import

```js
import { withIdleTimer } from 'react-idle-timer'
```

## Usage

There are a few ways to use the higher-order component, but at its core, the component
passed into `withIdleTimer` is enriched with the [IIdleTimer](/docs/api/methods) interface. 
The most common use cases are outlined below.

### IdleTimer Component

The first way is to create your own IdleTimer component and use it just like the 
v4 component.

Create the `IdleTimer` component that extends `IdleTimerComponent` instead of `Component`.

```js
import { Component } from 'react'
import { withIdleTimer } from 'react-idle-timer'

class IdleTimerComponent extends Component {
  render () {
    return this.props.children
  }
}

export const IdleTimer = withIdleTimer(IdleTimerComponent)
```

Use the `IdleTimer` component.

```js
import { Component } from 'react'
import { IdleTimer } from './IdleTimer'

export class App extends Component {
  constructor (props) {
    super(props)
    this.idleTimer = null
    this.onPresenceChange = this.onPresenceChange.bind(this)
    this.onPrompt = this.onPrompt.bind(this)
    this.onIdle = this.onIdle.bind(this)
    this.onAction = this.onAction.bind(this)
    this.onActive = this.onActive.bind(this)
  }

  onPresenceChange (presence) {
    // Handle state changes in one function
  }

  onPrompt () {
    // Fire a Modal Prompt
  }

  onIdle () {
    // Close Modal Prompt
    // Do some idle action like logging out your user
  }

  onActive (event) {
    // Close Modal Prompt
    // Do some active action
  }

  onAction (event) {
    // Do something when a user triggers a watched event
  }

  componentDidMount () {
    // IIdleTimer interface available on the reference to
    // the IdleTimer component instance
    this.idleTimer.start()
  }

  render () {
    return (
      <>
        <IdleTimer
          ref={ref => { this.idleTimer = ref }}
          timeout={1000 * 60 * 15}
          promptTimeout={1000 * 30}
          onPresenceChange={this.onPresenceChange}
          onPrompt={this.onPrompt}
          onIdle={this.onIdle}
          onAction={this.onAction}
          onActive={this.onActive}
          startManually
        />
        <HomePage />
      </>
    )
  }
}
```

### IdleTimer Injector

A better way would be to use the higher-order component to inject `IdleTimer` into your component. The event callbacks can be defined in your component scope and all the rest of the properties can be passed to your component.

Create the `IdleTimer` wrapped component.

```js
import { withIdleTimer, IdleTimerComponent } from 'react-idle-timer'

class AppComponent extends IdleTimerComponent {
  onPresenceChange (presence) {
    // Handle state changes in one function
  }
  
  onPrompt () {
    // Fire a Modal Prompt
  }

  onIdle () {
    // Close Modal Prompt
    // Do some idle action like logging out your user
  }

  onActive (event) {
    // Close Modal Prompt
    // Do some active action
  }

  onAction (event) {
    // Do something when a user triggers a watched event
  }

  componentDidMount () {
    // The IIdleTimer interface is supplied via props to your component
    this.props.start()
  }

  render () {
    return <HomePage />
  }
}

export const App = withIdleTimer(AppComponent)
```

Use the wrapped `IdleTimer` component.

```js
import { render } from 'react-dom'
import { App } from './App'

const element = document.getElementById('root')
render((
  <App 
    timeout={1000 * 60 * 15}
    promptTimeout={1000 * 30}
    startManually
  />
), element)
```

The wrapped component can also be instantiated deeper in the project hierarchy.
This would allow you to dynamically supply and update the [IIdleTimerProps](/docs/api/props)
interface to the `IdleTimer` instance.

```js
import { Component } from 'react'
import { App } from './App'

export class Root extends Component {
  constructor (props) {
    super(props)

    this.state = {
      timeout: 1000 * 60 * 15,
      promptTimeout: 1000 * 30
    }
  }

  render () {
    return (
      <App 
        timeout={this.state.timeout}
        promptTimeout={this.state.promptTimeout}
        startManually
      />
    )
  }
}

```

## Typescript

You can preserve your typescript types by utilizing the `withIdleTimer` generics.
Just make sure your props interface extends [IIdleTimer](/docs/api/types#IIdleTimer).

```tsx
import { Component, ReactNode } from 'react'
import { withIdleTimer, IdleTimerComponent, IIdleTimer } from 'react-idle-timer'

interface IAppProps extends IIdleTimer {
  foo: string
}

interface IAppState {
  bar: string
}

class AppComponent extends IdleTimerComponent<IAppProps, IAppState> {
  onPresenceChange (presence) {
    // Handle state changes in one function
  }
  
  onPrompt (): void {
    // Fire a Modal Prompt
  }

  onIdle (): void {
    // Close Modal Prompt
    // Do some idle action like logging out your user
  }

  onActive (event: Event): void {
    // Close Modal Prompt
    // Do some active action
  }

  onAction (event: Event): void {
    // Do something when a user triggers a watched event
  }

  componentDidMount (): void {
    // The IIdleTimer interface is supplied via props to your component
    this.props.start()
  }

  render (): ReactNode {
    return (
      <h1>{this.props.foo}</h1>
    )
  }
}

export const IdleTimer = withIdleTimer<IAppProps>(AppComponent)
```

Elsewhere in your app, render the typescript component. Your custom props will
be merged with the [IIdleTimer](/docs/api/methods) interface.

```tsx
import { Component, ReactNode } from 'react'
import { render } from 'react-dom'
import { App } from './App'

class Root extends Component<{}, {}> {
  render (): ReactNode {
    <App
      foo='bar'
      timeout={1000 * 60 * 15}
      promptTimeout={1000 * 30}
    />
  }
}

const element = document.getElementById('root')
render(<Root />, element)
```

## Examples

<Flex direction='column' mt={8}>
  <CodeSandboxButton name='higher-order-component-9fyvnr'>Higher Order Component</CodeSandboxButton>
</Flex>
